“To Be Esteemed, Be Useful”. A premise so simple and sound, it was one of the earliest mottos of the United States, appearing on their coinage of 1792. Sadly, it seems that this principle is ignored in the intellectual-property reform circuit.
I see a lot of people saying “I used a Creative-Commons style license on my project” or “It’s free under the Bla Bla Bla license” (substitute your favourite) and thinking they’re doing something about the abuse of the intellectual property system.
Just stop. These “permissive” licenses fail that fundamental test– they won’t maximize the overall usefulness of your work, so they deserve no esteem whatsoever. Instead of a simple goal of “get the most value out of my work”, you end up with a lot of compatibility and practical issues, all because we stuck to the framework of “I’m permitting you to do these things”.
I’m bundling here any licenses that allow redistribution with restrictions as permissive. Yes, they can be further analyzed seperately, but much of what’s said applies to the theme of permissive licensing, more so than specific choices.
Compatibility’s a Bitch
The first issue they create is the one of compatibility. The software people have tried to sort this one out, and there are even grand tables of “this plus this can/cannot be distributed.” Big deal. You’ve still got the problem of having to work around license compatibility, even if there’s a cheat sheet to follow.
This has lead to some comical situations. For example, if I wanted to re-package Zen-Cart with some of its best after-market addons, streamlining deployment and saving users dozens of man-hours, although both are licensed “GPL”, the combination can’t be shipped. The GPL version 2 of the main body didn’t match up with the version 3 of the addons.
Stop Enforcing Your Values
Second, not everyone is able to fit into the same licensing framework that you idealize. For example, even if you want to release fully open-source drivers for your widget, you may rely on modules supplied by third parties with different objectives, or face a regulatory or cultural situation which requires you provide “security through obscurity”. I doubt the FCC (or your local equivalent) wants to see end users having access to the “peak output power” control in wireless device drivers, and the banking industry really loves security-by-obscurity.
The opposite side of the coin also applies– perhaps your downstream contributors or users want to use a less restrictive license– for example, moving from GPL down to MIT, or even public-domain– and then your license choice actually becomes an impediment to further usefulness.
The end result is obvious by looking at a site like Freshmeat/Freecode– we have numerous projects which exist to build workalikes for things where the license was not suitable for the need. Real efficient.
The Cost of Compliance
Third, even without a financial cost, there’s the compliance cost. Just having to maintain the overhead of “this comes from A, and has license B attached” becomes a big deal fast, as the number of assets to manage grows. Everyone has to stop and check “could this be considered a derivative work of that?”– and possibly waste effort on replacing trivial elements just to ensure there’s no potential license toxicity. Also multiply it by different jurisdictions– the exceptions provided by Fair Use doctrine in the US don’t necessarily map 1:1 with those offered in other countries.
In addition, even if you’re keen on actually following the licenses to the letter, many of them have surprising catches buried in them. For example, the GPL requires those who distribute binaries to provide an offer for source code. Are you on the hook if you participate in a BitTorrent swarm to get a Linux ISO? Who’s going to be the test case in court?
What about attribution-based licensing– the BSD and MIT licenses, for example. Are they so terrible? Yes, in their own way. First, mandating attribution turns something that’s a moral judgement– “is the way I’ve used this work deserving of credit and/or is it plagarism?”– into a legalistic rule. Second, the requirements themselves can also become onerous. Remember the licenses on older BSD UNIX systems which required detailed credits to the contributors in the advertising? That may have made it more difficult to commercialize the product, explaining why Linux, not 386BSD, carried the day.
You Won’t Lose Your Identity
I can understand the fear– “what if my work becomes popular, but my contribution becomes anonymous?” Surprisingly little of an issue. Google is your friend– if people start celebrating “Bubba’s knockoff of your project”, all you need to do is show how yours was first, and strangely, 98% identical. You may even be able to show up the other contributor by offering deeper inside understanding or better services.
I can sort of sympathise the people who go “restrictive” with their works. There’s a lot of fear and a lot of concern– the easy-to-use “just sell copies and try to pretend that technology doesn’t exist” business plan which succeeded (for some people) for the last 50 years requires restrictive licensing and the law to back it up. It’s like the guy who goes to work in a franchise restaurant instead of becoming a chef and developing his own new restaurant.
However, if you already understand that you won’t halt unauthorized distribution of your work– which a permissive license choice suggests you do– then why insist on adding conditions which interfere with the work providing its greatest possible value?
Solutions
What should you do instead? Embrace the truly unrestricted. Public Domain or the equivalent. Maybe you like the legalistic CC0, or the more in-your-face WTFPL. And for everyone else, let’s look for workarounds like setting up laws forcing mandatory licensing– allowing us to ‘flip the script’ from “What the author allows us to do” to “Here’s what we want to do, what do I have to pay to make it happen?”
I’ve been rooting for this as well. Abandon copyleft, embrace copyfree.
I massively support permissive BSD and MIT over the restrictive GPL; I think Stallman and the Gnu’s want to take over the world with GPL, one project at a time, but it’s clearly not working.
Yeah, because that one obscure GPL licensed project called Linux didn’t achieve anything like total dominance in the server space – let’s all license our work under BSD/MIT so mega corporations can have a field day ripping it off and intruducing their favourite bonus features like “DRM”, “spying for free”, “controlling what you can/can not do” and the like predominantly without telling you or giving you any recourse should you not like these super-useful features (as determined by all-knowing CEO, who are you to complain – “market” decided what’s good for you so just shut up and stop whining).
Isn’t a lot of that a matter of authenticity and “web of trust” issues?
Regardless of licenses, for example, security-related products tend to require external vetting to earn enough trust to become useful standards.
The “extend and add nasty features” thing is also something which can be solved in the market. Look at what happened with the Chrome/Chromium code– you have Google’s binary-only version, or one of several different third-party builds (ChromePlus, SRWare Iron, Comodo Dragon, etc.) which may not be able to include all of Google’s features, but have their own features to offer. If you don’t trust Google, you can still get 98% of Chrome without using their build.
“tend to require external vetting” – yeah, and the easiest and most secure way to get that external vetting is being open-source so as many as possible people can audit it. And you can also do an “internat vetting” if you so desire – this is what GPL ensures nobody can take away from you as opposed to BSD where anybody can close the source at any time and you’re done.
The “extend and add nasty features” are not being solved by “the market”, they’re being solved because the sources are open – this is what both BSD and GPL provide …. however GPL provides the added value of preventing that anybody can just add those nasty features without telling you (or it being obvious) which is something BSD or public domain doesn’t prevent.
All in all GPL has all the advantages of public domain and “permissive” licenses + many more and eliminates some of their problems.
It’s more of a incentive system.
If I offer my Happy Magic Crypto Plus ™ under a propriatery license, odds are, nobody is going to check it out in the first place and build that initial base of trust that triggers wide adoption. I have to make at least that module available if I want to ever sell it.
As for ‘extend and add features’.
There’s a common saying in the Open Source community, something like “with enough eyes, all bugs are shallow”… but it also goes the other way. Even if you added nasty code to an open base, it might not go observed for months– Look at the panicked announcements when source repositories are compromised. Nobody was paying attention and bad code got out– in spite of the license allowing watching.
One thing I must say– considering the strong opinions and potential for vitriol on the topic, and the comment volume, everyone’s been very respectful and polite. I have to give kudos all around.
There’s a difference in philosophy that makes me choose CC0 over WTFPL, even though the latter has a lot more attitude to it.
WTFPL says “I permit you to do absolutely anything with this piece.”
CC0 says “I reject the notion that I can permit or forbid anybody to take a particular action with this piece.”
Therefore, I prefer CC0.
This article caught me by surprise Mr. Falkvinge. Usually your articles are pretty well thought out but this one stucks me as very superficial – it makes the impression of being a knee-jerk reaction to some hurdle that crossed your path and you’ve written this article under the emotional infulence of that episode.
That would explain the one-sided focus on hurdles you might come accross while using licenses such as GPL while neglecting to even consider their advantages – the very reason they were concieved of in the first place.
The truth is that we live in a system that by default makes us de facto dictators of whatever we create called copyright – this is our current reality and our choice of license (or no license) needs to take that reality into consideration.
If I find the imposition of developer’s will on the users of their software (like DRM, spying, backdoors, adware etc.) ethically repugnant and I’d give my work into public domain (or licensed under any if the “permissive” licenses) should I in your opinion accept that my work can be incorporated into such a product not only without any attribution but very likely used to dominate and control other people which I find the anti-thesis of what I believe in?
You’ve chosen your prefered license for an imaginary world without copyright – you are talking about a world as you’d want it to be instead of as it actually is. In a world without copyright I w’d agree with your choice, however in the world we actually live in we need to find a choice that nullifies the damage caused by copyright the best we can and that is the GPL which prevents others to use copyright against the people, the users. This is not the case for public domain or “permissive” licenses which “permit” you to only put more restrictions on the users of the software and to dominate them. That’s why I’ll never put my code into public domain so it can be incorporated into propritary software used to opress people.
After we abolish copyright, yeah, why not … until then the GPL is the best choice, not one without issues (like your GPLv2/GPLv3 compatibility) but far far the best that is available to us. The alternative being that we spend time and effort on coding things that will ulitmately be used against us, against freedom giving corporations a free lunch – that’s not my idea of advocating freedom. It’s not the only issue of software “being useful” but also HOW useful … most of the corporations/governments have very different idea of what it means to be “useful” than you do. For me being useful means advancing the cause of freedom and that only GPL can deliver.
You may want to note that this is not my article, but Jack Zeal’s – hence the different style of writing. I encourage guest writers in the realm of information policy.
Lol, actually the icon is so well incorporated into the picture that it is completely invisible.
Eh, I did not notice that indeed – maybe it could be more prominently displayed with an “Author” label. 😉
So that explains the sloppy reasoning (no offense, that’s how I see it and am willing to defend/explain it) thank you.
So I could contribute an article of my own, say about why I think GPL best protects our freedom as a whole in long term? I’d like to do that some time ….
I encourage it.
Much of it is tied into the meaning of the word “useful”.
For me, “useful” is “getting into the largest number of possible applications with the least burden on the user”.
I tend to view things from the consumer perspective, since all of us are far bigger consumers than we are producers.
I’m honestly a little unsure how licenses help avoid the use of your work for abusive/repressive aims.
Say Al-Queda builds a bomb control system on top of Linux. All they need to do is dump a source tarball on their servers and their legal obligations are met. That’s even assuming the use is noticed and litigated. There are only a few “can’t be evil” licenses and they aren’t popular.
It does come down to the definition of useful. And focusing on the usefulness of the given picture, font or software for whatever endeavour some human find it fit for is a fine thing.
But.
If I make software program A, which is the most brilliant databse ever, except for one little tiny error – and MS, Apple, or Google fix it and slap a copyright notice on it, then its usefulness for any human endeavour has been severely limited.
That is the extreme case, for the actual use case, consider how much free software Google is using to spy on everyone. An AGPL license would, if you are still unsure, bar Google from selling work that was meant to serve the public to back to the same public in exchange for their private data.
We are not trying to make “you can’t use this work for evil”-licenses. We are trying to make “this work must remain free” licenses.
The consumer perspective is fine – but what the consumer needs is an end to software pseudo-monopolies and lock-in. A copyleft license helps them do that, public domain code lets the big players get ahead as much as the cooperating consumers and producers – and they are not interested in choice, freedom or interoperability.
As you allude to ‘rush to post’ effects, either vet your own text or start sleeping with an editor.
Copyleft forces everyone who re-uses your code or material to also release it under a useful licence. The forced usefulness in several generations definitely outweighs any loss in usefulness due to licence incompatibilities. There is probably a reason that the most used (and hence demonstrably the most useful) projects in their respective fields are the ones that use copyleft, and thus forces forks and derivative works to be published in a way that allows them to be folded back into the main project – the Linux kernel, GCC, Wikipedia…
Exactly, GPL ensures that nobody can take your or others freedom away, BSD/MIT style licenses do not, they insted allow someone along the way to strip your freedom away and give themself power over users (you) once again.
Not a great tool when your goal is spreading freedom, but great if you do not care and want to pander to big business (the ever present excuse about “adoption”).
The term “permissive” license is a misnomer – “I permit you to restrict others” and some call that “freedom”, yeah … isn’t that an oxymoron?
I’m also not a big fan of the GPL, more liberal licenses are better for example LGPL is quite good as you can mix such code with any other code, having to put the LGPLed code into a library is only a minimal annoyance.
David X.
As long as copyright persists releasing code under a completely free license only has a positive impact on the usefulness of your own code, releasing under a strong copyleft license not only makes your own code useful, it also makes any future derivates of it useful and increases the incentive for others to release their code under a permissive license aswell. The more code there is released under for example the GPL the more developers have to gain by using a license with the same or less restrictions (GPL Licensed code can be mixed freely with code using a license that doesn’t add any additional restrictions so it effectivly only sets the upper limit for how far one can restrict his users/customers freedom while still benefiting from the work of others).
There are definitly cases for both license types today, a developer should simply ask himself what is most important, to maximize the usefulness of the code in question or to help maximize the amount of useful code.
While simply abolishing copyright would make any released code as useful as possible it wouldn’t do anything to ensure that more useful code is released. (Binaries that you’re legally allowed to modify, copy and distribute aren’t really useful if it is prohibitivly difficult to do so).
These thoughts are seemingly fine.
As long as you keep the projects small.
The problem with just leaving things totally free is that it creates ridicolous amounts of abuse and fragmentation.
If Linux for instance would have been fully free instead of forced freedom there would exist thousands of kernels today, and I mean active, divergent ones.
Also, it would open the door to people releasing versions of linux which would simply NOT WORK except on a specific hardware set, and more importantly, put out drivers which only worked with very specific kernels.
So, abuse and fragmentation.
But, yeah, license incompatibility is an issue, however, the point of the GPL is to restrict people from producing software which in someway hides what it is doing from it’s users.
In essence, any personal use of the program or derivatives of the program should ALWAYS be free, the only way to do that is to require that if you are a publisher (note that you can for instance mirror isos without being a publisher of said software) you must produce the code you used to create the code and that any derivative of the mentioned code must adhere to the same principles.
Even with this quite clear and simple rules, people try to abuse them and whine that they can’t abuse them legally.
But, yeah, the ultimate thing would be license-free.
Whether projects fragment often has little to do with the license and more to do with project goals. For example, I can see a system like Android eventually fragmenting from mainstream Linux because it needs to service seperate goals– nobody’s going to want to run Ice Cream Sandwich on their embedded 68030 systems!
A strong relationship with stakeholders can help prevent fragmentation, but sometimes it makes more sense to stop trying to incorporate mutually incompatible aims.
No, it really has to do with licenses. Because a fragmentation can have the force of law behind it, if we all put code into the public domain. This is impossible if we use copyleft licenses.
And – we don’t just want to stop fragmentation in order to prevent 4+ forks. We want to stop the non-free, non-useful PR-boosted and “value-added” fork from running roughshod over everyone elses.
I like to use the broadest possible CC licensing, for unlimited redistribution and sale so long as it’s attributed to me as author. I usually include a tongue-in-cheek statement of the Woody Guthrie License: “Anyone found to be distributing this material without our permission will be considered mighty good friends of ourn, because we don’t give a dern.”
I think it is fine to embrace the regulatory aspects of copyleft licenses if one realizes that they don’t conceptually depend on copyright, rather just the current implementation does. If access to and ability to modify and share modified source is socially valuable in at least some contexts, it makes sense for regulation (market, institutional, government; whatever your preference, most likely a mix) to mandate such, eg so that safety and security of a self-driving car is open to inspection and auditing. A bit more at http://gondwanaland.com/mlog/2012/01/31/copyleft-regulates/
Also note that there’s plenty of room for innovation – legal, marketing, and otherwise – in maximally permissive licenses/public domain dedications, see http://gondwanaland.com/mlog/2012/02/25/permissions/
(For now I primarily use CC0 but see an important role for regulatory licenses, including AGPL for software services, in the current environment.)
Mike
This ideal of “being useful” is very much 18th-century-enlightenmentish
A german “enlightened” prince , Franz von Anhalt-Dessau even had as his motto: To teach and be useful (Belehren und nützlich seyn).
The pirate movement is definitely a direct follower and a modern day banner holder of the enlightenment ideals of free knowledge and the power to change the world inherent in networked encyclopedic visions, without claims for domination.
As long as you are talking about your code and additions to it the notion of forcing people to disclose their additions to your code is ok.
It however is not ok if we are talking about a big complex project someone made and than needs a few small additions from foreign code to force him to license the whole work under the license o some minor part.
LGPL is ideal here as you can put the foregin code with your small additions into a library and license your main project where you put the most of your work in under any license you want.
My point is simple that it is not morally justifiable to limit someones rights on a big peace of work he did only because he wants to use some minor foreign peaces.
So ideally any project that is made up to more that 51% of your own code you should be allowed to license any way you want no mater under which license the remaining 49% are.
So you you would to for example rewrite 50% of the Linux kernel you should be free to do WTF you want as it is in a majority our own work.
David X.
I agree a lot with your statement. It’s funny how there are some pieces of code that become the “tail that wags the dog”. Probably the most famous is the readline library– it’s potentially useful, but their license choice has made it fairly toxic.
Just a link that might interest you 😉
http://venezuelanalysis.com/analysis/6913
The suggested text for applying the GNU GPL allows distributing under any later version of the license, so by default there is no problem. The problem only arises when some people (allegedly the authors of Zen-Cart) modifies it to permit only version 2. I would not contribute to a project that cannot be distributed under later versions of the license.
GPLv3 also eliminates the problem with distributing binaries using Bittorrent. Getting a program distributed under GPLv3 by Bittorrent does not require acceptance of the license. http://www.gnu.org/licenses/gpl-faq.html#BitTorrent
GPL, LGPL and AGPL are tremendously useful to protect the freedom of all users, even though it can be hard work to comply with the license when creating and modifying programs and distributions. Non-copyleft licenses however, such as various Creative Commons licenses, BSD, MIT and Apache, only make compliance difficult without providing any value. Therefore I simply put things in the public domain instead of using non-copyleft licenses.
I agree that it’s not important to require attribution. Someone made a modified version of an Android application I have made and removed my name from it, but I’m content with that, as the GPL was not removed, so users of the modified version still have their freedom protected by the GPL.
‘And for everyone else, let’s look for workarounds like setting up laws forcing mandatory licensing– allowing us to ‘flip the script’ from “What the author allows us to do” to “Here’s what we want to do, what do I have to pay to make it happen?”’
This seems to contradict what goes before it.
I don’t believe it is reasonable to, on one hand, say “Stop Enforcing Your Values” and suggest each individual should stop enforcing mandatory licencing on downstream users of their work, then suggest that we should try to enforcing mandatory licencing on EVERY work.
For me, while copyright exists, the choice of licence is a matter of strategy, rather than an absolute. I use BSD, MPL and GPL for code I write, with the choice depending on the nature of the code.
Rather than the original author being able to enforce HIS values, the user gets the chance to trade to whatever license he needs to accomplish his aims.
You might, for example, get a work offered under GPL (or, equally likely, some commercial license) for free or the normal cost, but the potential user can just go to the mandatory-licensing bureau and find out the necessary cost to “buy them out” and use the license he’d prefer.
So, how would this mandatory licencing proposal work?
Say I wanted to distribute my own, tweaked version of Windows; who would set the price I have to pay. Can Microsoft set their own price (which presumably would be set so high as to be unafforable), or would it be some government body making their own judgement of what I should pay? Would they have to provide me with source code, or would I be left with a right in principle which I can’t exercise in practice?
I can’t see a way compulsory licencing could be anything other than either completely ineffectual, or so onerous that it would be easier for all concerned to abolish copyright altogether.
I figure it would have to be the state– it’s disinterested and able to legally enforce its choices.
Microsoft would, of course, say Windows is worth $604 trillion to relicense, but you’d counter offer with $1.49.
Given the ability to acquire any sort of content you need, I could almost see it more as a “clean-up” system– find that Windows source somewhere, do what you need, they buy retroactive peace. Actually, that’s a related facet of the mandatory license theme that really appals to me– rather than having to do all the work of clearing licenses ahead of time, causing schedule slippage, you’d just cut a cheque once someone complains.
Behind GPLs there’s efficiency. How can I make my code useful for the humanity and my community? Proprietary software is useful? No. I’m forced in this age to embrace copyleft. It is necessary to hold the usefulness of my contribution. I cannot allow any waste of work, through the form of proprietary/all right reserved data.
We could think abandoning copyleft licences in the future, not now.
> I think Stallman and the Gnu’s want to take over the world with GPL, one project at a time, but it’s clearly not working.
Aehm
http://osrc.blackducksoftware.com/data/licenses/index.php
I strongly disagree with the article. We’re still fighting uphill battle against incumbent proprietary industry. Until the vast majority of end users understands why access to source code is more important than shiny coating, we can’t afford to use licences that don’t enforce openness.
When you allow the proprietary industry to take over your project, add a shiny coating and close it down, you may reach a bigger audience and your project’s usefulness will jump high, but at the peak, its usefulness will flatline. The original open project will probably quietly die in obscurity.
When you use licence which forbids closing down, this can’t happen. Your project’s usefulness will keep snowballing exponentially long after you leave the project and probably even after you die. In the end, GPL delivers much more usefulness long-term.
Sadly I have to agree. Although Mr. Zeal’s motivation is of a high standard, the main problem is that his solution only practically works in a paradigm where patenting and licensing are NOT the norm.
If you want your code to see extensive use, a CC0 license could be the way to go. But a license is, unfortunately, necessary under todays paradigm. Anything “unowned” in any way will be locked down by whatever company finds it profitable.
And if there is any ambiguity – any at all – expect a future legal battle where you get swamped in briefs issued by the legal department of Microsoft or Oracle.
Creative Commons should not be necessary. It’s like having to put a legal provision on something you’ve created for the public good merely in order to prevent the first unscrupulous idiot to come along from locking it down and preventing it’s use from said public.
That said, I fully agree with Mr. Zeal’s philosophy in general.
This article is pretty terrible. Have we not already learnt our lesson from Apple taking a BSD project and turning it into OS X?
Which underscores what I’ve said for years. If your intent is to create something for the good of all, you are ill served when most of the use in effect becomes a locked-down proprietary product as soon as someone with a decent lawyer comes along.
GPL basically ensures that you cannot take a free product and turn it into a proprietary one. I think Stallman, when he created GPL, was actually looking for a weapon. Because that’s what GPL is. A way to tacitly combat the effectiveness of proprietary software.
I believe the OP is correct in that GPL licensing is cumbersome. It shouldn’t be necessary and from any practical perspective it is insane that you should have to surround that which you want to give away freely with a complex legal framework.
But as long as the idea of “Intellectual Property” exists in it’s current interpretation it will do the sheep no good to preach the goodness of a diet of grass if the wolves are of a different mind.
@Scary Devil Monastery
You are talking about locking down free software by commercial vendors, pardon me, but this is bulshit!
Only because Apple took Unix code and made a proprietary MacOS X out of it does not make the original BSD licences Unix code any bit less free or locked down in any way.
They made something new that isn’t free any more, but they don’t made anything that was previously free unfree.
So you can argue just as good that apple didn’t do any harm, to the OpenSource stuff but just added some commercial stuff, stuff that wouldn’t be there at all if they wouldn’t be allowed to use the free stuff.
So at least looking globally without such CC0 like licences that total amount of stuff would be smaller.
There for one can just as well argue that restrictive free licences have a negative impact at the amount of stuff that is being made.
Also I strongly disagree with the notion that closed source software is by default worthless, actually for 99% of the people c++ code is just as unreadable as a binary file.
So for the majority of humans the only thing that matters is the amount of available stuff, not weather it is open or closed source.
Howe ever I agree that on a long time scale closed source software always becomes obsolete, while open source stuff can always be reused to some extent those preserving some its value over time.
So as long as the software is up to date booth closed and open source software have a good value for the user.
But while closed source stuff at some point always becomes obsolete, open source stuff is kind of immortal.
David X.
>There for one can just as well argue that restrictive free licences have a negative impact at the amount of stuff that is being made.
Explain. Perhaps you mean “the amount of code that is being written” which is a different concept, and probably a positive one. (less work, same results)
>Only because Apple took Unix code and made a proprietary MacOS X out of it does not make the original BSD licences Unix code any bit less free or locked down in any way.
From my point of view proprietary software is a waste of human resource, because it needs software with the same purpose to be rewritten. Look at GNUstep, Mono, Moonlight, Octave, Gnash and the infinite others free implementations of proprietary technologies: they would be completely useless if their mothers were free.
It’s why we need copyleft. It is like an antivirus, the more code is GPLed, less proprietary code is being written and less time is wasted until all the code is gpled. Anyway, avoid abuses overcomes most problem with licences, i think.
>>There for one can just as well argue that restrictive free licences have a negative impact at the amount of stuff that is being made.
>
> Explain.
I mean the amount of software available for normal users (not programmers) that they can use.
A typical user is better of to be able to choose form
mac os x or unix
than having only one choice
unix
in booth cases the normal user can not modify the software in any way, so for them the hypothetical possibility of being able to modify unix is not relevant at all.
>>Only because Apple took Unix code and made a proprietary MacOS X out of it does not make the original BSD licences Unix code any bit less free or locked down in any way.
> From my point of view proprietary software is a waste of human resource, because it needs software with the same purpose to be rewritten.
I bag to differ while to some extent the work is done multiple times, this is not necessarily a bad thing.
I myself when writing stuff often arrive at points where I completely scrap some existing code part and redo it form scratch, resulting in much better code.
Now, a closed source system while not being that easy to rework as you have at once redo everything without insight into the inner workings of the old code, forces never the less a rework, those giving opportunity to do things better.
Also a closed system is never completely closed, for example lets take apples ios, while you can not use their code directly you can still observe many solutions they developed, learn form them and re implement them like google with android, of cause it would be easier to simply copy and paste their code but then you will loose out on a opportunity to do it better.
Lets assume Microsoft would have open sourced windows at the very begin why should anyone develop linux. They would just fork windows.
I’m not saying in any way that Closed source is better, just that it is not that much worser, and that it is needer less usefully (as for 99% of the users its booth open and closed source plain black magic) nor a waste of resources.
David X.
You say you scrap the existing and probably bad written code keeping the good part. With closed source you can’t see the code at all. I don’t think free software increases centralization, on the contrary the more than twenty foss systems developed since 90s are the proof of the extreme fragmentation of this environment.
>Lets assume Microsoft would have open sourced windows at the very begin
It’s like assuming that the problem of closed source never existed.
>I’m not saying in any way that Closed source is better, just that it is not that much worser, and that it is needer less usefully (as for 99% of the users its booth open and closed source plain black magic) nor a waste of resources.
If we would talk from the perspective of the present medium users we couldn’t even understand the aim behind GNU project at all. In this sense, every software is useful, it’s not accident that GPL is mainly for developers. As an advanced user and sometimes developer, closed source is the absolute evil or a waste of resource, is the same.
The issue often becomes “what was the propriatery component and how does its value fit into things.” For example, I’d expect a lot of the propriatery bits of MacOSX are tied into Apple-specific hardware and the GUI engines.
Let’s say it’s 2022 and you want to make a MacOSX clone. You might start with Darwin, but odds are, you won’t bother reimplementing, say, PowerPC drivers for a Radeon X1650– not much call for those anymore. You might even rip out most of the Cocoa(?) interface and replace it with stub code that maps onto some more modern or compatible framework.
The long-term value of what they’re keeping to themselves may be virtually nil, but if letting them go closed source gives us some benefits in the short term, I’m not going to beef.
That’s an interesting point. Reuse cuts both ways– you get the features and the bugs. I wonder if one got the right to use the Windows or OSX source, if they might just say “WTF” and throw 95 percent of it away.
Also, can you get me an appointment with Doctor Sevarius? 🙂 🙂 🙂
“but if letting them go closed source gives us some benefits in the short term, I’m not going to beef.”
This says it all, it’s EXACTLY this kind of short-term shorsighted thinking that got us into the mess we’re in. “Let’s give auhtors an exlusive monopy rights so we can watch Twilight and Star Wars row row!” Never mind the cost to society in diminished liberties, eventual opression by these monopolies and squasing of culture and most independent artists in long term.
Maximum period of thinking ahead 2 years. It’s very apparent that anything beyond that is also beyond authors vision as when he talks about “maximizing usefulness” it’s also in that kind of timeframe – let’s not think about what’s going to happen 5 years into the future, just that I can use the code how I want right NOW right HERE.
I’m sorry I’m bitching in this way but the moment somebody starts talking about “the market” as some kind of an entity I know exactly what to expect as I’m almost certainly dealing with a flavour of a “free-market” ideologue who doesn’t base his opinions on logic and a set goal but by dogmas that don’t make sense when examined in depth (or even not so in depth).
No Mr., it’s not “the market” that solves the aberrations of corporate creations and “extent and add nasty features” problem – it’ dedicated people with vision of a better world, programmers that predominantly license their works under the GPL, organizations like the EFF, FSF and others who work tirelessly to defend the users – these are people with names, names that are not hard to find out – it is insulting to call them “the market”.
I’m kind of irrirtated so I’m sorry if my tone is too strong, I can not stand “reasoning” like this. I do not blame the author, he is obviously free to express his opinions and I’m glad we can have a discussion about it but I also hope it will stir him int researching and thinking about this more deeply and long term, maybe he’ll come to understand why I’m so irritated by what he writes 😉
> gives us some benefits in the short term
LOL, are there benefits from closed source? The user security and privacy treats deriving from the closure of the code are already a “benefit” to avoid like hell. In personal computing THERE AREN’T benefits from proprietary software for the user.
In an ideal world, perhaps, we’d have a fully functioning market.
However, there’s often a “closed or nothing” situation due to the effects of external forces. Maybe you require some firmware written by an unenlightened firm and only offered as a binary. Maybe there’s really a terrible secret in your code that you’d prefer to keep hidden– video card performance enhancement drivers, I’m looking at you– but the code even in a closed fashion can have value. I think it’s fair to make a call that “nothing” may not be as useful as the closed-source option.
“Closed or nothing” situations exist until free software hasn’t conquered the market. And copyleft speeds up the process; in the big market, public domain it’s just a window on abuses, it’s useless in the effort to make freedom the rule.
Anyway, I don’t understand how could you, as a pirate, have defended closed sourcing.
>Anyway, I don’t understand how could you, as a pirate, have defended closed sourcing.
Because piracy is about freedom freedom of everyone, if you forces people to do things open source you are limiting their freedom.
So the most pirate compatible was is to completely abolish any restrictions, meaning that you can handle everything as CC0 and at the same time reverse engineer everything.
David X.
Well said. “You can’t have dessert” and “You must have chocolate eclairs for dessert every single day forever” are both repressive, even if one seems more generous or well intentioned.
I feel like one of the things that got lost in the discussion is that the benefits of open-source and the equivalent vary by the material in question.
Software has a lot of functional aspects– so a propriatery extension can lock down functionality. I can see why there’s a lot of people rushing to prevent it.
But say you forked a TV show or novel– The fork would never be considered canonical, and it’s unlikely it would be widely adapted. So there’s little to be gained by mandating a license on the result.
@David
Preventing producers closing my code isn’t “limit their freedom”, is avoid help them create a monopoly.
The reasons behind the restriction of copyleft are the same behind the law “you can’t kill another human being”, the same behind our copyright reform: limit the rights of few to protect the freedom of all.
> But while closed source stuff at some point always becomes obsolete, open source stuff is kind of immortal.
That single sentence sums up perfectly why enforcing openness is important. See, UNIX has been down this road about 35 years ago and almost got destroyed as a result. (See Eric Raymond’s The Art of Unix Programming, particularly part 1, chapter 2: http://www.faqs.org/docs/artu/historychapter.html)
When you say that closed source stuff at some point becomes obsolete, you essentially agree that all the effort that was put into it eventually goes to waste. And it DOES harm the original project because a lot of the wasted effort could have gone into the original project instead of the proprietary one which has stolen the spotlight. The thing that nearly killed UNIX 30 years ago was that the community fractured into many closed forks and people stopped caring about the original open core. What made the problem even worse was that management of all those closed projects completely ignored the emerging PC market and focused on mainframes and supercomputers. When PCs took over most of the enterprise market in early 90s, all those proprietary UNIX forks were pretty much dead. The only project that was still alive was BSD, probably the only still open fork, but also years behind its proprietary competition.
So what do you propose MacOS users do when Apple decides to dump MacOS? Should they switch to BSD which is still stuck in late 90s and moves ahead at snail’s pace? No, they’ll probably switch to Linux which can keep up with the pace at the edge because nobody can steal its spotlight by selling the same thing but closed with extra candy on top.
It’s not just licenses that keep the community unfragmented, though. Much of it is philosophical and design decisions.
Even if you fork an “enforced open” project, there’s no guarantee it makes sense to backport the changes, or that it will be taken. So you’ll still end up with two projects, as the fork tries to maintain feature parity with the original, plus maintain the changes that led to the original fork.
A license is a “philosophical and design decision”, they’re so tightly linked it almost doesn’t make sense to speak separatly of them.
Th fact that it ‘sometimes’ doesn’t make sense to backport changes from a forked project is not a good reason to throw away the 99% ofcases where is DOES make sense.
Forks are a GOOD thing, it’s a failsafe protection mechanism and most of the time only the threat of somebody forking a project makes developers honest and listening to its users.
> When you say that closed source stuff at some point becomes obsolete, you essentially agree that all the effort that was put into it eventually goes to waste.
No, basing on this reasoning any effort that was put into something that has an expiration date goes to waste.
Like a car, a pc, a good dinner, bottled water, a house.
And I think that is not correct, if the thing benefited some one for some time it already justified its existence and the work that was put into it isn’t waisted.
Do you think that if there wouldn’t be closed source software today we would the same amount of various software at hand?
We would certainly had better software to do more tasks. Perhaps less software to do the same thing.
> We would certainly had better software to do more tasks. Perhaps less software to do the same thing.
I don’t think so.
I think that the amount of software to do the same thing, correlates with the how good the best of this programs does the thing it does.
If you need a software to do something you can eider take something that is already there or do something own.
Now if the existing thing works for you satisfying you wont do an own thing if you need it. But would you have to code it on your own you might do it better than the existing solutions do it.
So the more different software to do a thing you have the better the best software there is does its thing.
> We would certainly had better software to do more tasks. Perhaps less software to do the same thing.
I assume thats not correct.
I think that the amount of software to do the same thing positively correlates with how good the best software does its thing.
So the more software you have to do the same thing the better on the long run will be the best software that does this specific thing.
Every time someone needs something done, he eider writes a new software or uses an existing one, if he uses an existing one and gets a satisfying result he wont do a new one, loosing out on the opportunity to do a software that produces a very good result.
Now the goal is in the long run to get the best software out there in a free form.
but to achieve this we need 2 things, 1 the best solution to do something to be found and 2 this solution to be made free.
Now, having only open source I think we would loose out on 1.
As not so much people would be looking to the optimal solution and using the easy available one instead.
So I believe that while closed source software does not help in the second thing (having a open solution), it helps in the first thing (having the best solution) and thats the most important one, as without the best solution being found in the first place it can not be made available for free.
David X.
>Every time someone needs something done, he eider writes a new software or uses an existing one, if he uses an existing one and gets a satisfying result he wont do a new one, loosing out on the opportunity to do a software that produces a very good result.
Remembering you that from medium user perspective more features mean better software and that source availability means more features, the amount of total software isn’t related to free software percentage, or at least not like you intend.
In every field opensource solutions are the cornerstone, there’s a lot of same-purpose software, because of what you say: because bad-written code is thrown away, is ignored and replaced.
Closed source means less code in general, because people except those in the work can’t contribute (due to the extreme difficult of rewrite a program from the scratch) and structural problems (that lead to the write of completely new software) are not evident.
If it was how you affirmed, a simple example like counting the number of free against closed OSes should give you reason then…
>Every time someone needs something done, he eider writes a new software or uses an existing one, if he uses an existing one and gets a satisfying result he wont do a new one, loosing out on the opportunity to do a software that produces a very good result.
Remembering you that from medium user perspective more features mean better software and that source availability means more features, the amount of total software isn’t related to free software percentage, or at least not like you intend.
In every field opensource solutions are the cornerstone, there’s a lot of same-purpose software, because of what you say: because bad-written code is thrown away, is ignored and replaced.
Closed source means less code in general, because people except those in the work can’t contribute (due to the extreme difficult of rewrite a program from the scratch) and structural problems (that lead to the write of completely new software) are not evident.
If it was how you affirmed, a simple example like counting the number of free against closed OSes should give you reason then…
I’m sorry for mispellings and double posting of the last message, I hope the meaning is clear.
> Do you think that if there wouldn’t be closed source software today we would the same amount of various software at hand?
The answer to this question depends on the reason why there wouldn’t be any closed source software in the first place. But in most of the sane cases, yes, I DO think we’d have the same amount of various software at hand. In fact, we’d be even farther ahead thanks to heavy reuse of code shared among commercial competitors! Really, write down the list of all sane reasons for why there wouldn’t be any proprietary software in the first place (starting with the one we’re aiming for: the public valuing openness above extra features) and extrapolate the history of software market from 1970s onward for each item on the list.
> No, basing on this reasoning any effort that was put into something that has an expiration date goes to waste. Like a car, a pc, a good dinner, bottled water, a house.
BTW, I never would have thought that I’ll see the “idea is like physical object” fallacy from a Pirate.
>> No, basing on this reasoning any effort that was put into something that has an expiration date goes to waste. Like a car, a pc, a good dinner, bottled water, a house.
>
>BTW, I never would have thought that I’ll see the “idea is like physical object” fallacy from a Pirate.
I’m not saying in any way that ideas are like physical object.
I’m only saying that any work that benefited people even it only temporary can not be considered waisted work.
> I’m only saying that any work that benefited people even it only temporary can not be considered waisted work.
And I’m saying it can if the result of that work comes in the form of idea. Suppose that every single inventor of fire could keep the details secret from everybody else. Then we’d still be living in caves and reinventing fire every 20 or so years instead of doing something more useful. That’s the point I’m trying to make here.
> And I’m saying it can if the result of that work comes in the form of idea. Suppose that every single inventor of fire could keep the details secret from everybody else. Then we’d still be living in caves and reinventing fire every 20 or so years instead of doing something more useful. That’s the point I’m trying to make here.
Even if the every time newly invented fire would help only one person its inventor to get food instead of starving this work is not waisted.
Of cause if the idea is shared it have a benefit for the entire human race.
But that fact that the idea isn’t shared and only benefited one person does not make the work put into the idea waisted.
David X.
I agree totally with next_ghost.
It isn’t wrong reinventing each time the wheel, it’s wrong (and it’s a waste of work) being forced reinventing it because of its proprietary license.
> it’s wrong (and it’s a waste of work) being forced reinventing it because of its proprietary license.
But its not because of a license, its because the idea is not disclosed publicly, as its closed source.
You are not forced to do that because someone simple disallows you to use an existing solution, but because he does not discloses the solution to the public .
Thats not the same thing.
The software which doesn’t give the four freedoms, to me (and to who wrote the GPLs) is unethical and malicious, and in any case at least worth avoiding it at all.
Not using it is therefore reinventing the wheel entirely.
https://www.gnu.org/philosophy/free-sw.en.html
Although it is true that Apple did not “lock down” their proprietary builds based on BSD it is equally true that Apple has since gone to war extensively over any software containing as much as a single line of apple code. The same more or less holds true for any major software company. The proprietary portion of any software renders any 3rd-party use of even the open modules very risky.
I concur with some of your reasoning but in real practice if you tamper with a piece of code to be found on an Apple device, chances are you may have to waste effort in a court of law defending your right to do so.
When a company interlinks proprietary models with open code they will always at least try to lock it down as tightly as possible, in real practice. At least as soon as the application you’ve written turns out to be useful.
GPL enforces the tacit acknowledgment by any user of a line of code that his/her efforts are indeed open for use by anyone else. Any ambivalency in this results in SCO-tactics in practice.
> Only because Apple took Unix code and made a proprietary MacOS X out of it does not make the original BSD licences Unix code any bit less free or locked down in any way.
> They made something new that isn’t free any more, but they don’t made anything that was previously free unfree.
Can you share OS X with other people? Can you (legally) install OS X in a PC? Can you modify OS X for your personal purposes? Can you *remove DRM* from your installation of OS X?
NO. You can’t. Because OSX is a closed source software. Is OSX usefull?
Simply… who care? OSX is NOT free (as in freedom) nor free (as a beer) nor PUBLIC. In fact OSX as Windows are shit.
GPL is an ethical, PUBLIC and collaborative license.
The main GPL goal is about free knowledge and collaboration between people, not to be more productive or to gain millions of dollars/euro against civil rights.
> Also I strongly disagree with the notion that closed source software is by default worthless, actually for 99% of the people c++ code is just as unreadable as a binary file.
So for the majority of humans the only thing that matters is the amount of available stuff, not weather it is open or closed source.
The only thing that matters with Open Source *and GPL* software aganinst closed, is that *everyone* can *legally* change the sources, even when a program is a “commercial” software, not that specifically *You* can do that.
So, i can buy an Android smartphone, remove the manifacturer provided operating system and install a more secure, spyware free, Android modification.
Can you do that with an iPhone?
>Can you do that with an iPhone?
What iphone without the closed source ios there wouldn’t be an iphone.
And who cares about what you can do and can not do with Max OSX it does not affect in any way what you can do with Unix..
Jack,
You don’t have a clue. Sorry, but I call it like I see it. You don’t understand your subject.
The multiple projects is the BEST THING YOU COULD SEE.
You’ve obviously never heard of my attempt to apply Darwinian Evolutionary Theory to software projects. One of the conclusions that I reached was the more projects working on a particular area, the faster that software in that area would evolve.
Freeing up a project’s license would have the opposite effect that you want. It would be less efficient, because the software would be less capable.
Wayne
An interesting thesis.
I personally tend to think that the software world tends to eventually turn into “infrastructure” and “applications”.
Infrastructure software tends to reach a level of maturity and freeze-in-place. For example, even if the guys who are doing WINE want to fix or improve the Win32 API, they can’t because the world is built to expect the faults in Microsoft’s version. A lot of key libraries and interfaces get there, and the momentum against changing them gets worse every day. All you really need for them is one good implementation without showstopping licensing problems.
OTOH, Applications, indeed, can compete and evolve at a much faster rate.
[…] The author was a mysterious web developer and Arizonian named Jack Zeal, and the post, entitled To Be ; detailed the cumbersome nature of licenses, even those designed to promote free use. Mr. Zeal […]